Project update¶
Section 1: Project Overview¶
Provide an overview of your project including the research questions. You may start with the text from your proposal but it must be edited for clarity and any updates to your thinking.¶
Formula 1 is a racing sport and the pinnacle of mechanical engineering where 10 teams (constructors) race each other for the world championship (mostly glory). We are considering data from 1950, the time that Formula 1 started, to 2017. As in any typical sport, the world championships of Formula 1 racing are decided by a number of parameters such as qualifying race times (these races usually happen before the main race to determine the starting positions of the cars in the main race) , lap times ( the time for a driver to go around a track once) and most importantly pit stop timings (when the tires of the cars are changed, the car is refueled, any broken parts are replaced) to name a few.
This is interesting because the person who is in front of the grid (a grid is the positioning of the cars from the start line of the race) may not necessarily win every time. Teams can follow a variety of different strategies, i.e., perform an undercut, overcut or push when required, in order to gain an advantage in the later stages of a specific race. This variation of data can be analyzed and visualized in numerous ways. Formula 1 being the bleeding edge of mechanical engineering provides a framework for the cars that are going to be designed in the future (usually the automobile technology that is being used in these cars, take a lot of time to be incorporated into normal cars) and therefore this analysis is significant.
Questions of Interest
â How many drivers who did not start the race in the first position went on to win?
â How many times has a constructor(teams) won at that specific venue over the years?
â How has the pitstop times changed over the years?
â Who is the driver who has won the most number of formula 1 championships in history?
Expected findings
â Our analysis indicates that over a period of time, there is a significant reduction in the pitstop time.
â The driver who has the maximum number of race wins, points and championships is Michael Schumacher.
As is, there has been no change to our research questions. Going forward, we intend to analyze car design changes over the years and how they have impacted results.¶
Section 2: Milestones and Progress¶
In bullet points or a table, list the project milestones from your proposal for dates up to November 4th. Have you met these milestones? If not, explain what you will do to catch up.¶
What resources will you need to accomplish your next steps? What is unclear in your plan?¶
â Data scraping and cleaning
Sumukh Sharma
10/18/2019
â Managing missing data
Sumukh Sharma
10/22/2019
We have created a document which has all the basic information about how we need to plug in data and manage missing information. It is as follows:
Formula 1 data mapping and managing:Circuits: **
circuitId - Use as key
circuitRef
name
location
country â Useful to specify by country
lat - latitude
lng - longitude
alt
urlConstructors: **
constructorId â use as key
constructorRef
name
nationality
urlDrivers: **
driverId â Use as Key
driverRef
number â Fill blanks with -1
code
forename
surname
dob
nationality
urlRaces: **
raceId â Use as Key
year â Season of the race
round â Race number in that year
circuitId â Same as Circuitid from circuit
name
date
time â Fill blanks with 10:00
urlResults: ***
resultId
raceId â Use key from Races
driverId â Use key from Drivers
constructorId â use key storm constructors
number â Driver number(5 for vettel, May not be unique). Fill Blanks with -1
grid â Starting grid position
position â Finishing position. Fill blanks with -1 for retired cards
positionText â Position Text. R stands for retired
positionOrder â Final position order ( This ideally should be the same as position 1âŚn where n is number of cars that took part in that race)
points â Points won
laps â Number of laps driven in a race. Any driver that retired will have a lower number than those that finished for a specific RaceID
time
milliseconds
fastestLap â Gives fastest lap number
rank â Rank of the fastest lap times
fastestLapTime â Lap time
fastestLapSpeed â Avg speed in the fastest lap
statusId â StatusId of the car at the end of the race. Use key from Status ( Finished. Did not finish. Disqualified. Power unit issues. Etc.)Seasons: *
Year - year
urlStatus - **
statusId â Use this as a key
status â Status of the car at the end of the race and the reason for retiring.Constructor results: *
constructorResultsId â Use as Key
raceId - Use key from Races
constructorId â Use key from Constructors
points â Points scored
status â Null/ D (D for disqualified)Constructor Standings:*
constructorStandingsId
raceId â Use key from Races
constructorId â Use key from Constructors
points â Points scored â Fill Blanks with 0
position â Position of constructor
positionText - Text
wins â Wins in that year
#### * indicate the importance of the data tables
#### : foundation data table
#### : Important data table
#### : Critical data table
â Indexing, selection and filtering
Malav Parekh & Pratik Pandey
11/3/2019
- Indexing of DataFrames has been done. Selection and filtering are not currently required, so they have been kept for the later stages of analysis. In order to clean the data, some DataFrames have been updated and null vlaues have been managed.
All milestones have been met so far¶
Since we have already imported the data, we will not need any further resources to proceed with our project implementation. However, in the coming days, as we progress, we intend to use 'Google Colab' for effective collaboration between the members of the project.¶
Section 3: Data Acquisition and Cleaning Code¶
Please provide code that demonstrates that you have made progress with data acquisition and cleaning. In a markdown cell at the top of the section, summarize what you have accomplished thus far.¶
1. We have imported the NumPy and Pandas modules.
2. We have read the .csv files (11 in total) relevant to our project and stored them in DataFrames
3. Three .csv files ('circuits.csv', 'pitStops.csv' and 'drivers.csv') were in TextIOWrapper form. We have converted them into DataFrames and done required cleaning and indexing.¶
4. We have created copies of these DataFrames and are going to work on these copies so that we can pull out the original tables in case of future use.
5. We have created indices for each of the DataFrames
6. We have managed missing values and eliminated NaN values for the DataFrames, including the most important DataFrame 'results' (its copy).¶
In [1]:
# Importing required modules
import pandas as pd
import numpy as np
driverStandings.csv¶
In [2]:
# Reading the 'driverStandings.csv' file and creating a copy of it.
driverStandings = pd.read_csv('driverStandings.csv')
driverStandingsCopy = driverStandings.copy()
#driverStandingsCopy
In [3]:
# Renaming its columns
driverStandingsCopy.rename(columns = {'driverStandingsId':'driverStandingsId', 'raceId':'raceId', 'driverId':'driverId',
'points':'Points', 'position':'Position',
'positionText':'positionText', 'wins':'Wins'}, inplace = True)
# Setting the index to 'driverStandingsId'
driverStandingsCopy.set_index('driverStandingsId',inplace=True)
driverStandingsCopy
Out[3]:
results.csv¶
In [4]:
# Reading the 'results.csv' file and creating a copy of it.
results = pd.read_csv('results.csv')
resultsCopy= results.copy()
#resultsCopy
In [5]:
# Renaming its columns
resultsCopy.rename(columns = {'resultId':'resultId', 'raceId':'raceId', 'driverId':'driverId',
'constructorId':'constructorId', 'number':'Number', 'grid': 'Grid',
'position':'Position', 'positionText':'positionText', 'positionOrder': 'Position order',
'points':'Points', 'laps':'Laps', 'time':'Time','milliseconds':'Time in milliseconds',
'fastestLap': 'Fastest Lap', 'rank': 'Rank', 'fastestLapTime': 'Fastest Lap Time',
'fastestLapSpeed':'Fastest Lap Speed', 'statusId':'statusId'}, inplace = True)
resultsCopy.set_index('resultId',inplace=True)
In [6]:
#Handling null values for multiple columns in 'results.csv'
values = {'Position': -1, 'Number': -1, 'Time': 0, 'Time in milliseconds': 0}
resultsCopy.fillna(value=values)
Out[6]:
circuits.csv¶
In [7]:
# Opening the circuits.csv file
# It is a TextIO Wrapper file
circuitsWrapper = open('circuits.csv', encoding = "ISO-8859-1")
circuits = pd.DataFrame(circuitsWrapper)
In [8]:
# Appending the valuesinto a list
list_circuits=[]
# Since the values are comma seperated and stored in a list, we split them
rowLabels_circuits=circuits[0][0].split(',')
# Looping through the length of the DataFrame
for i in range(1,74):
values=circuits[0][i].split(',')
list_circuits.append(values)
# Storing the newly appended list in a DataFrame
circuitsUpdated=pd.DataFrame(list_circuits)
#circuitsUpdated
In [9]:
# Creating a copy of the above created DataFrame
circuitsCopy= circuitsUpdated.copy()
#circuitsCopy
In [10]:
# Renaming the columns
circuitsCopy.rename(columns = {0:'circuitId', 1:'CircuitRef', 2:'Name', 3:'Location',
4:'country', 5:'Latitude', 6:'Longitude', 7:'Altitude', 8:'URL'}, inplace = True)
#circuitsCopy
In [11]:
# Setting the index as 'circuitId'
circuitsCopy.set_index('circuitId',inplace=True)
In [12]:
# # Dropping redundant columns
circuitsCopy.drop(['Altitude', 9], axis=1, inplace=True)
circuitMap=circuitsCopy
circuitsCopy
Out[12]:
In [13]:
circuitMap
Out[13]:
constructorResults.csv¶
In [14]:
# Reading the 'constructorResults.csv' file and creating a copy of it.
constructorResults = pd.read_csv('constructorResults.csv')
constructorResultsCopy= constructorResults.copy()
#constructorResultsCopy
In [15]:
# Renaming its columns
constructorResultsCopy.rename(columns = {'constructorResultsId':'constructorResultsId', 'raceId':'raceId',
'constructorId':'constructorId', 'points':'Points',
'status':'Status', 5:'Latitude', 6:'Longitude', 7:'Altitude', 8:'URL'}, inplace = True)
# Setting the index
constructorResultsCopy.set_index('constructorResultsId', inplace=True)
#constructorResultsCopy
In [16]:
#Handling null values
values = {'Status': 'NULL'}
constructorResultsCopy.fillna(value=values)
Out[16]:
constructors.csv¶
In [17]:
# Reading the 'constructors.csv' file and creating a copy of it.
constructors = pd.read_csv('constructors.csv')
constructorCopy= constructors.copy()
#constructorCopy
In [18]:
# Renaming the columns
constructorCopy.rename(columns = {'constructorId':'constructorId', 'constructorRef':'ConstructorRef',
'name':'Name', 'nationality':'Nationality', 'url':'URL',
'Unnamed: 5':'Unnamed: 5'}, inplace = True)
# Setting the index
constructorCopy.set_index('constructorId',inplace=True)
In [19]:
# Dropping redundant column
constructorCopy.drop(['Unnamed: 5'], axis=1, inplace=True)
constructorCopy
Out[19]:
constructorStandings.csv¶
In [20]:
# Reading the 'constructorStandings.csv' file and creating a copy of it.
constructorStandings = pd.read_csv('constructorStandings.csv')
constructorStandingsCopy = constructorStandings.copy()
#constructorStandingsCopy
In [21]:
# Renaming the columns
constructorStandingsCopy.rename(columns = {'constructorStandingsId':'constructorStandingsId', 'raceId':'raceId',
'constructorId':'constructorId', 'points':'Points', 'position':'Position',
'positionText':'positionText','wins':'Wins', 'Unnamed: 7':'Unnamed: 7'}, inplace = True)
# Setting the index
constructorStandingsCopy.set_index('constructorStandingsId',inplace=True)
In [22]:
# Dropping redundant column
constructorStandingsCopy.drop(['Unnamed: 7'], axis=1, inplace=True)
constructorStandingsCopy
Out[22]:
drivers.csv¶
In [23]:
# Opeing the 'drivers.csv' TextIOWrapper file
driversWrapper = open('drivers.csv', encoding = "ISO-8859-1")
drivers = pd.DataFrame(driversWrapper)
In [24]:
# Creating a list
list_drivers=[]
# Splitting the comma seperated values
rowLabels_drivers=drivers[0][0].split(',')
# Looping through the length of the DataFrame
for i in range(1,843):
values=drivers[0][i].split(',')
# Appending the values to the list
list_drivers.append(values)
# Creating a new DataFrame by using the list
driversUpdated=pd.DataFrame(list_drivers)
#driversUpdated
In [25]:
# Creating a copy of the DataFrame
driversCopy= driversUpdated.copy()
#driversCopy
In [26]:
# Renaming the columns
driversCopy.rename(columns = {0:'driverId', 1:'DriverRef', 2:'Number', 3:'Code',
4:'Forename', 5:'Surname', 6:'DOB', 7:'Nationality', 8:'URL'}, inplace = True)
#driversCopy
In [27]:
# Setting the index
driversCopy.set_index('driverId',inplace=True)
In [28]:
# Dropping redundant column
driversCopy.drop([9], axis=1, inplace=True)
driversCopy
Out[28]:
In [29]:
# Opening the 'pitStops.csv' file and creating a copy of it after converting it to DataFrame from TextIOWrapper.
pitStopsWrapper = open('pitStops.csv', encoding = "ISO-8859-1")
pitStops = pd.DataFrame(pitStopsWrapper)
#pitStops
In [30]:
# Create a list
list_pitStops=[]
# Splitting the comma seperated values in the wrapper file
rowLabels_pitStops=pitStops[0][0].split(',')
# Looping through the length of the Dataframe
for i in range(1,6252):
values=pitStops[0][i].split(',')
# Appending the values to the list
list_pitStops.append(values)
# Creating a new DataFrame and adding the list to it
pitStopsUpdated=pd.DataFrame(list_pitStops)
#pitStopsUpdated
In [31]:
# Creating a copy of the DataFrame
pitStopsCopy= pitStopsUpdated.copy()
#pitStopsCopy
In [32]:
# Renaming the columns
pitStopsCopy.rename(columns = {0:'raceId', 1:'driverId', 2:'Stop', 3:'Lap',
4:'Time', 5:'Duration', 6:'Duration in milliseconds'}, inplace = True)
#pitStopsCopy
In [33]:
# Setting the index
pitStopsCopy.set_index('raceId',inplace=True)
In [34]:
pitStopsCopy
Out[34]:
races.csv¶
In [35]:
# Reading the 'races.csv' file and creating a copy of it
races = pd.read_csv('races.csv')
racesCopy = races.copy()
#racesCopy
In [36]:
# Renaming the columns
racesCopy.rename(columns = {'raceId':'raceId', 'year':'Year','round':'Round', 'circuitId':'circuitId', 'name':'Name',
'date':'Date','time':'Time', 'url':'URL'}, inplace = True)
# Setting the index
racesCopy.set_index('raceId',inplace=True)
race2=racesCopy
racesCopy
Out[36]:
seasons.csv¶
In [37]:
# Reading the 'seasons.csv' file and creating a copy of it
seasons = pd.read_csv('seasons.csv')
seasonsCopy= seasons.copy()
#seasonsCopy
In [38]:
# Renaming the columns
seasonsCopy.rename(columns = {'year':'Year','url':'URL'}, inplace = True)
# Setting the index
seasonsCopy.set_index('Year',inplace=True)
seasonsCopy
Out[38]:
status.csv¶
In [39]:
# Reading the 'status.csv' file and creating a copy of it
status = pd.read_csv('status.csv')
statusCopy = status.copy()
#statusCopy
In [40]:
# Renaming the columns
statusCopy.rename(columns = {'statusId':'statusId','status':'Status'}, inplace = True)
# Setting the index
statusCopy.set_index('statusId',inplace=True)
statusCopy
Out[40]:
Analysis 1: Drivers who won after not being in pole position¶
In [123]:
print("Number of winners: "+str(len(results[results['position'] == 1.0])))
In [42]:
resultsCopy=resultsCopy[resultsCopy['Position'] == 1.0]
In [43]:
resultsCopy=resultsCopy[resultsCopy['Grid'] != 1]
In [124]:
print("Number of winners who were not in grid position 1: "+str(len(resultsCopy)))
So the number of drivers who won the race even after not starting in pole position was 572 out of 979. The rate of conversion stands pretty high at 58.4% which is massive and does not give us a meaningful analysis. Hence, we will focus on drivers who didn't start in the first 3 posiitons and still went on to win, to gain better insight of how difficult it actually is.¶
In [45]:
required_drivers = resultsCopy[resultsCopy['Grid'] > 3].sort_values('Grid',ascending=False).drop_duplicates(subset='Grid',keep='first')
required_drivers
Out[45]:
As we can see, if we filter out drivers who started the races in first three grid positions and went on to win the race, we are only left with 17 entries out 979. This is a massive drop in proportion from 58.4% to 1.7%. This gives us an idea of how difficult it is to win races from grid positions 4 and beyond.¶
But some drivers have managed the extraordinary.¶
Let us focus on those who achieved the impossible, by starting in positions 15th and beyond and still went on to win it.¶
In [46]:
required_drivers = resultsCopy[resultsCopy['Grid'] > 15].sort_values('Grid',ascending=False).drop_duplicates(subset='Grid',keep='first')
required_drivers
Out[46]:
In [47]:
df=pd.DataFrame()
df = [ driversCopy[driversCopy.index == j] for i in required_drivers['driverId'] for j in driversCopy.index if int(j) == i]
#df
In [48]:
drivers_url=[]
for i in range(len(df)):
drivers_url.append(df[i].URL)
In [49]:
from bs4 import BeautifulSoup
import requests
In [50]:
from IPython.display import Image
In [51]:
path = "/Users/prati/FormulaOne/Images/"
Image(filename = path + "Watson.jpg", width=250, height=250)
Out[51]:
John Watson¶
- United States Grand Prix, 1983
- Grid position: 22
In [52]:
Image(filename = path + "Cross.png", width=250, height=250)
Out[52]:
Art Cross¶
- Indianapolis 500, 1954
- Grid Position: 19
In [53]:
Image(filename = path + "Barrichello.png", width=250, height=250)
Out[53]:
Rubens Barrichello¶
- German Grand Prix, 2000
- Grid Position: 18
In [54]:
Image(filename = path + "Raikkonen.png", width=250, height=250)
Out[54]:
Kimi Raikkonen¶
- Japanese Grand Prix, 2005
- Grid Position: 17
In [55]:
Image(filename = path + "Schumi.png", width=250, height=250)
Out[55]:
Michael Schumacher¶
- Belgian Grand Prix, 1995
- Grid Position: 16
Analysis 2: But who is the greatest in history???????¶
In [56]:
pit_time_list1 = pd.DataFrame(pitStopsCopy.loc['881']['Duration'])
mean_list_for_a_race1 = pit_time_list1['Duration'].astype(float).mean()
mean_list_for_a_race1
Out[56]:
In [57]:
pd.set_option("display.max_rows", 100)
pd.set_option("display.max_columns", 99)
driverStandingsCopy = driverStandingsCopy.fillna(0)
driverStandingsCopy
Out[57]:
In [58]:
driver_wins = {}
for index, row in driverStandingsCopy.iterrows():
if row["Position"] == 1:
if row["driverId"] in driver_wins.keys():
driver_wins[row["driverId"]] += 1
else:
driver_wins[row["driverId"]] = 1
#driver_wins
In [59]:
driverStandingsDf= pd.DataFrame(driverStandingsCopy)
driversDf= pd.DataFrame(driversCopy)
In [60]:
driverStandingsDf=driverStandingsDf.sort_values('driverId')
In [61]:
driversCopy.head()
Out[61]:
In [62]:
driversCopy.reset_index(inplace=True)
In [63]:
print(driversCopy.dtypes, driverStandingsCopy.dtypes)
In [64]:
driversCopy['driverId']=driversCopy['driverId'].astype('int')
In [65]:
driverStandings
Out[65]:
In [66]:
data=pd.merge(driverStandingsCopy, driversCopy, on='driverId', how='left')
data
Out[66]:
In [67]:
data.groupby(['DriverRef']).count().sort_values(by='Wins', ascending=False, inplace=True)
data
Out[67]:
In [68]:
data = data[data["Position"]==1]
data["Surname"].value_counts()
Out[68]:
In [69]:
import matplotlib.pyplot as plt
#import plotly.plotly as py
import plotly.graph_objs as go
import chart_studio
import chart_studio.plotly as py
colors = ['grey'] * 55
colors[0] = 'crimson'
chart_studio.tools.set_credentials_file(username='pratikp', api_key='AHxozWNTaluAU7sx4YW7')
data1=[go.Bar(x=data["Surname"].value_counts().index, y=data["Surname"].value_counts().values, marker_color=colors)]
py.iplot(data1,filename='Wins by Drivers')
Out[69]:
Based on the bar chart plotted above, we can see that Michael Schumacher stands out in terms of number of wins registered in the history of Formula One. He has won a total of 121 races and has 7 championship titles in total. The difference is huge between him and Prost, who comes in at position 2 with 79 wins. All these statistics are enough to usggest that he is the GOAT (Greatest of all time)¶
In [70]:
unique_raceid_list = list(pitStopsCopy.index.unique())
Analysis 3: Decline in pitstop times¶
One important aspect in Formula One racing is pit stops. These play a major role in determining who goes on to win the race and depending on how efficiently time is managed during pit stops, wins are decided by milliseconds.¶
In 2010, tyre rules were changed. Bridgestone withdrew from the racing scene and in June 2011, Pirelli announced that it will be providiing tyres to teams. Refuelling was banned during races. These changes led to drastic decrease in ptistop times as can be seen in the line graph below.¶
In [71]:
pit_stops_average_df = pd.DataFrame(columns=['Year', 'Average_pit_time'])
for year in range(2011,2018):
# print(year)
race_list_for_year = racesCopy[racesCopy['Year']==int(year)].index.unique()
mean_list_for_a_race = []
for race in race_list_for_year:
# print(race)
try:
pit_time_list = pd.DataFrame(pitStopsCopy.loc[str(race)]['Duration'])
mean_list_for_a_race += [pit_time_list['Duration'].astype(float).mean()]
except:
print(race)
mean_list_for_a_race
mean_dfrow_for_a_specific_year = pd.DataFrame(mean_list_for_a_race)
# float(mean_dfrow_for_a_specific_year.mean())
pit_stops_average_df = pit_stops_average_df.append({'Year':int(year),'Average_pit_time': float(mean_dfrow_for_a_specific_year.mean())}, ignore_index=True)
pit_stops_average_df
Out[71]:
In [72]:
pit_time_list = pd.DataFrame(pitStopsCopy.loc['969']['Duration'])
# mean = pit_time_list.mean()
meann = pit_time_list['Duration'].astype(float).mean()
#meann
In [73]:
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style("whitegrid")
sns.lineplot(x=pit_stops_average_df.Year, y=pit_stops_average_df.Average_pit_time);
plt.ylabel('Time')
plt.title('Year')
# plt.xticks(rotation='vertical');
Out[73]:
As we can see from the line graph plotted above, pitstop times took a huge plunge in 2012 after the introduction of new rules. there is an upward trend from 2012 to 2013 but that is because there were a lot of cases of explosive tyre bursts mid race and that was a major contributor in drivers having to visit pitstops more often. It was due to manufacturing issues in Pirelli tyres. Overall, pitstop times have been gradually declining over the years and are helping constructors achieve clocked times like never before.¶
Analysis 4: Which constructor has won the most races at a particular circuit?¶
In [74]:
racesCopy['circuitId']=racesCopy['circuitId'].astype('int')
In [75]:
racesCopy=racesCopy.reset_index()
In [76]:
circuitsCopy=circuitsCopy.reset_index()
In [77]:
circuitsCopy['circuitId']=circuitsCopy['circuitId'].astype('int')
In [78]:
#fig.update_layout(barmode='group', xaxis_tickangle=-45)
#fig.show()
In [79]:
data2=pd.merge(circuitsCopy, racesCopy, on='circuitId', how='left')
In [80]:
data2[['circuitId','Name_x','Location','country','raceId']]
Out[80]:
In [81]:
constructorStandingsCopy=constructorStandingsCopy.reset_index()
#constructorStandingsCopy
In [82]:
print(type(constructorStandingsCopy))
In [83]:
data3=pd.merge(data2, constructorStandingsCopy, on='raceId', how='left')
In [84]:
pd.set_option("display.max_rows", 12000)
data3.head()
Out[84]:
In [125]:
data3[data3['Position']==1.0].head()
Out[125]:
In [86]:
data8=data3.groupby(['circuitId','constructorId']).count()
In [87]:
#data8
In [88]:
data7=data3.groupby(['circuitId','constructorId']).count().sort_values(by='Wins',ascending=False)
In [89]:
#data7=data7.reset_index()
In [90]:
data9=data7
In [91]:
#data9
In [92]:
data10=data9.reset_index()
In [93]:
data11=pd.DataFrame(data10.groupby(by='circuitId')['Wins'].max())
In [94]:
#data10.groupby(['circuitId','constructorId']).sort_values(by='Wins',ascending=True).drop_duplicates(keep= 'last')
#data11
In [95]:
#data11=data10[['circuitId','constructorId','Wins']]
#data10
data12=pd.merge(data10, data11, on=['circuitId','Wins'], how='inner')
In [96]:
data13=data12[['circuitId','constructorId','Wins']]
In [126]:
data13.sort_values(by=['circuitId','constructorId'],ascending=True).head()
Out[126]:
In [99]:
#data13['Wins'] = data[['Year', 'quarter']].apply(lambda x: ''.join(x), axis=1)
In [127]:
data14=pd.merge(data13, circuitsCopy, on='circuitId', how='left')
data14[['circuitId','constructorId','Wins','Latitude','Longitude']].head()
Out[127]:
In [101]:
import plotly.express as px
fig1 = go.Figure(go.Densitymapbox(lat=data14.Latitude, lon=data14.Longitude, z=data14.Wins, radius=25))
fig1.update_layout(mapbox_style="open-street-map", mapbox_center_lon=180)
fig1.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
fig1.show()
In the above map, we have plotted the circuits and the number of maximum wins achieved by any constructor on that particular circuit.¶
Analysis 5: The most challenging circuits¶
Nelson Piquet once said,racing at Monaco—by far the most famous street circuit of them all—was "like trying to cycle around your living room."¶
Most races end up with some drivers retiring and not being able to finish the race. Primary reasons behind this are engine failures and difficult circuits.¶
The most challenging circuits are street circuits as they have a lot of barriers and these are the ones that face driver retirements more often than other circuits.¶
In [102]:
res=results
In [103]:
race=racesCopy
In [104]:
values = {'position': -1, 'number': -1, 'time': 0, 'milliseconds': 0}
res=res.fillna(value=values)
In [105]:
data4=pd.merge(res, race, on='raceId', how='left')
In [106]:
data4=data4[data4['position'] == -1.0]
In [107]:
data5=data4.groupby(['circuitId']).count().sort_values(by='raceId',ascending=False)
In [108]:
data5=data5.reset_index()
In [128]:
data5[['circuitId','number']].head()
Out[128]:
In [110]:
data6=pd.merge(data5, circuitsCopy, on='circuitId', how='left')
In [129]:
data6[['circuitId','number','Latitude','Longitude']].head()
Out[129]:
In [112]:
#import plotly.graph_objects as go
fig = go.Figure(go.Densitymapbox(lat=data6.Latitude, lon=data6.Longitude, z=data6.number, radius=35))
fig.update_layout(mapbox_style="stamen-terrain", mapbox_center_lon=180)
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
fig.show()
According to Bleacher Report, the 'Circuit De Monaco' is the most challenging circuit in the world and as seen in the visualization above, we can see that this circuit has had the most driver retirements standing at 843 followed by 'Autodromo Nazionale di Monza' in second.¶
Although the track in Monza is not a street circuit, it has high curve speeds which has resulted in a lot of fatal crashes and other accidents. Only drivers with proper techniques and superior aerodynamic efficiency are able to challenge for top spots here.¶
Another track which is very challenging is the 'Circuit Gilles Villeneuve' in Montreal, Canada and is rightly fourth on the list of most retired drivers.¶
Analysis 6: Formula 1- A global sport¶
In [115]:
circuitMap['Raceloc'] = 0
circuit_id_list = list(race2[race2['Year'] == 2018]['circuitId'])
circuit_id_list
Out[115]:
In [117]:
circuit_id_list_notlive_i = list(race2[race2['Year'] != 2018]['circuitId'])
circuit_id_list_notlive = [x for x in circuit_id_list_notlive_i if x not in circuit_id_list]
# len(circuit_id_list_notlive)
# len(circuit_id_list)
# circuitsCopy[~circuitsCopy['circuitId'].isin(circuit_id_list)]['Raceloc'] = 1
circuit_id_list
# circuit_id_list
for rowId in circuit_id_list:
circuitMap.loc[str(rowId),'Raceloc'] = 1
In [130]:
circuitMap.head()
Out[130]:
In [121]:
import seaborn as sns
import plotly.graph_objects as go
mapbox_access_token = 'pk.eyJ1Ijoic3VtdWtoc2hhcm1hIiwiYSI6ImNrMm92bjJydzE3c3UzcHQ1Nzdjb3JwNHMifQ.x_ybvMGOCORXoXDYqnJCCg'
class_map_data1 = go.Scattermapbox(
lon = circuitMap[circuitMap['Raceloc']!=1]['Longitude'],
lat = circuitMap[circuitMap['Raceloc']!=1]['Latitude'],
text = circuitMap[circuitMap['Raceloc']!=1]['Name'],
hoverinfo='text',
mode = 'markers',
marker = dict(
color = 'red',
symbol = 'circle',
opacity = .5
),
name = "Not live circuits"
)
class_map_data2 = go.Scattermapbox(
lon = circuitMap[circuitMap['Raceloc']==1]['Longitude'],
lat = circuitMap[circuitMap['Raceloc']==1]['Latitude'],
text = circuitMap[circuitMap['Raceloc']==1]['Name'],
hoverinfo='text',
mode = 'markers',
marker = dict(
color = 'green',
symbol = 'circle',
opacity = 1
),
name = "Live circuits"
)
class_map_layout = go.Layout(
title = 'Circuit Locations',
mapbox=go.layout.Mapbox(
accesstoken=mapbox_access_token,
zoom=1
)
)
class_map = go.Figure(data=[class_map_data1,class_map_data2], layout=class_map_layout)
class_map.show()